home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / machine / sprint2.c < prev    next >
C/C++ Source or Header  |  2000-04-04  |  10KB  |  322 lines
  1. /***************************************************************************
  2.  
  3. Atari Sprint2 machine
  4.  
  5. If you have any questions about how this driver works, don't hesitate to
  6. ask.  - Mike Balfour (mab22@po.cwru.edu)
  7. ***************************************************************************/
  8.  
  9. #include "driver.h"
  10. #include "vidhrdw/generic.h"
  11.  
  12. int sprint2_collision1_data = 0;
  13. int sprint2_collision2_data = 0;
  14. int sprint2_gear1 = 1;
  15. int sprint2_gear2 = 1;
  16.  
  17. static int sprint2_steering_buf1 = 0;
  18. static int sprint2_steering_buf2 = 0;
  19. static int sprint2_steering_val1 = 0xFF;
  20. static int sprint2_steering_val2 = 0xFF;
  21.  
  22. /***************************************************************************
  23. Read Ports
  24.  
  25. Sprint1 looks for the following:
  26.    AAAAAAAA          D                   D
  27.    76543210          6                   7
  28.    00101000 ($28)    n/a                 1st1 (player 1 1st gear)
  29.    00101001 ($29)    n/a                 1st1 (player 1 2nd gear)
  30.    00101010 ($2A)    n/a                 1st1 (player 1 3rd gear)
  31.    00101100 ($2B)    n/a                 Gas1 (player 1 accelerator)
  32.    00101101 ($2C)    n/a                 Self Test
  33.    00101110 ($2D)    n/a                 Start1
  34.  
  35.    00x10x00          Track Cycle (DIP)   Oil Slick (DIP)
  36.    00x10x01          Mode 0 $ (DIP)      Mode 1 $ (DIP)
  37.    00x10x10          Spare (DIP?)        Ext Play (DIP)
  38.    00x10x11          Time 0 (DIP)        Time 1 (DIP)
  39.  
  40. We remap our input ports because if we didn't, we'd need 16 ports for this.
  41. ***************************************************************************/
  42.  
  43. READ_HANDLER( sprint1_read_ports_r )
  44. {
  45.     int gear;
  46.  
  47.     gear=input_port_1_r(0);
  48.     if (gear & 0x01)                sprint2_gear1=1;
  49.     else if (gear & 0x02)           sprint2_gear1=2;
  50.     else if (gear & 0x04)           sprint2_gear1=3;
  51.     else if (gear & 0x08)           sprint2_gear1=4;
  52.  
  53.     switch (offset)
  54.     {
  55.             /* IN1 */
  56.             case 0x28:      if (sprint2_gear1==1) return 0x00; else return 0x80;
  57.             case 0x29:      if (sprint2_gear2==1) return 0x00; else return 0x80;
  58.             case 0x2A:      if (sprint2_gear1==2) return 0x00; else return 0x80;
  59.             case 0x2B:      return ((input_port_2_r(0) & 0x01) << 7);
  60.             case 0x2C:      return ((input_port_2_r(0) & 0x02) << 6);
  61.             case 0x2D:      return ((input_port_2_r(0) & 0x04) << 5);
  62.             /* DSW */
  63.             case 0x10:
  64.             case 0x14:
  65.             case 0x30:
  66.             case 0x34:      return ((input_port_0_r(0) & 0x03) << 6);
  67.             case 0x11:
  68.             case 0x15:
  69.             case 0x31:
  70.             case 0x35:      return ((input_port_0_r(0) & 0x0C) << 4);
  71.             case 0x12:
  72.             case 0x16:
  73.             case 0x32:
  74.             case 0x36:      return ((input_port_0_r(0) & 0x30) << 2);
  75.             case 0x13:
  76.             case 0x17:
  77.             case 0x33:
  78.             case 0x37:      return ((input_port_0_r(0) & 0xC0) << 0);
  79.  
  80.             /* Just in case */
  81.             default:        return 0xFF;
  82.     }
  83. }
  84.  
  85. /***************************************************************************
  86. Read Ports
  87.  
  88. Sprint2 looks for the following:
  89.    AAAAAAAA          D                   D
  90.    76543210          6                   7
  91.    00011000 ($18)    n/a                 1st1 (player 1 1st gear)
  92.    00011001 ($19)    n/a                 1st2 (player 2 1st gear)
  93.    00011010 ($1A)    n/a                 2nd1 (player 1 2nd gear)
  94.    00011011 ($1B)    n/a                 2nd2 (player 2 2nd gear)
  95.    00011100 ($1C)    n/a                 3rd1 (player 1 3rd gear)
  96.    00011101 ($1D)    n/a                 3rd2 (player 2 3rd gear)
  97.  
  98.    00101000 ($28)    n/a                 Gas1 (player 1 accelerator)
  99.    00101001 ($29)    n/a                 Gas2 (player 2 accelerator)
  100.    00101010 ($2A)    n/a                 Self Test
  101.    00101100 ($2B)    n/a                 Start1
  102.    00101101 ($2C)    n/a                 Start2
  103.    00101110 ($2D)    n/a                 Track Select Button
  104.  
  105.    00x10x00          Track Cycle (DIP)   Oil Slick (DIP)
  106.    00x10x01          Mode 0 $ (DIP)      Mode 1 $ (DIP)
  107.    00x10x10          Spare (DIP?)        Ext Play (DIP)
  108.    00x10x11          Time 0 (DIP)        Time 1 (DIP)
  109.  
  110. We remap our input ports because if we didn't, we'd need 16 ports for this.
  111. ***************************************************************************/
  112.  
  113. READ_HANDLER( sprint2_read_ports_r )
  114. {
  115.     int gear;
  116.  
  117.     gear=input_port_1_r(0);
  118.     if (gear & 0x01)                sprint2_gear1=1;
  119.     else if (gear & 0x02)           sprint2_gear1=2;
  120.     else if (gear & 0x04)           sprint2_gear1=3;
  121.     else if (gear & 0x08)           sprint2_gear1=4;
  122.  
  123.     if (gear & 0x10)                sprint2_gear2=1;
  124.     else if (gear & 0x20)           sprint2_gear2=2;
  125.     else if (gear & 0x40)           sprint2_gear2=3;
  126.     else if (gear & 0x80)           sprint2_gear2=4;
  127.  
  128.  
  129.     switch (offset)
  130.     {
  131.             /* IN0 */
  132.             case 0x28:      return ((input_port_2_r(0) & 0x01) << 7);
  133.             case 0x29:      return ((input_port_2_r(0) & 0x02) << 6);
  134.             case 0x2A:      return ((input_port_2_r(0) & 0x04) << 5);
  135.             case 0x2C:      return ((input_port_2_r(0) & 0x08) << 4);
  136.             case 0x2D:      return ((input_port_2_r(0) & 0x10) << 3);
  137.             case 0x2E:      return ((input_port_2_r(0) & 0x20) << 2);
  138.             /* IN1 */
  139.             case 0x18:      if (sprint2_gear1==1) return 0x00; else return 0x80;
  140.             case 0x19:      if (sprint2_gear2==1) return 0x00; else return 0x80;
  141.             case 0x1A:      if (sprint2_gear1==2) return 0x00; else return 0x80;
  142.             case 0x1B:      if (sprint2_gear2==2) return 0x00; else return 0x80;
  143.             case 0x1C:      if (sprint2_gear1==3) return 0x00; else return 0x80;
  144.             case 0x1D:      if (sprint2_gear2==3) return 0x00; else return 0x80;
  145.             /* DSW */
  146.             case 0x10:
  147.             case 0x14:
  148.             case 0x30:
  149.             case 0x34:      return ((input_port_0_r(0) & 0x03) << 6);
  150.             case 0x11:
  151.             case 0x15:
  152.             case 0x31:
  153.             case 0x35:      return ((input_port_0_r(0) & 0x0C) << 4);
  154.             case 0x12:
  155.             case 0x16:
  156.             case 0x32:
  157.             case 0x36:      return ((input_port_0_r(0) & 0x30) << 2);
  158.             case 0x13:
  159.             case 0x17:
  160.             case 0x33:
  161.             case 0x37:      return ((input_port_0_r(0) & 0xC0) << 0);
  162.  
  163.             /* Just in case */
  164.             default:        return 0xFF;
  165.     }
  166. }
  167.  
  168. /***************************************************************************
  169. Sync
  170.  
  171. When reading from SYNC:
  172.    D4 = ATTRACT
  173.    D5 = VRESET
  174.    D6 = VBLANK*
  175.    D7 = some alternating signal!?!
  176.  
  177. The only one of these I really understand is the VBLANK...
  178. ***************************************************************************/
  179. READ_HANDLER( sprint2_read_sync_r )
  180. {
  181.     static int ac_line=0x00;
  182.  
  183.     ac_line=(ac_line+1) % 3;
  184.     if (ac_line==0)
  185.             return ((input_port_3_r(0) & 0x7f) | 0x80);
  186.     else
  187.             return (input_port_3_r(0) & 0x7F);
  188. }
  189.  
  190.  
  191.  
  192. /***************************************************************************
  193. Coin inputs - Nothing special here.
  194. ***************************************************************************/
  195. READ_HANDLER( sprint2_coins_r )
  196. {
  197.     return (input_port_4_r(0));
  198. }
  199.  
  200.  
  201.  
  202. /***************************************************************************
  203. Steering
  204.  
  205. When D7 is low, the steering wheel has moved.
  206. If D6 is low, it moved left.  If D6 is high, it moved right.
  207. Be sure to keep returning a direction until steering_reset is called,
  208. because D6 and D7 are apparently checked at different times, and a
  209. change in-between can affect the direction you move.
  210. ***************************************************************************/
  211. READ_HANDLER( sprint2_steering1_r )
  212. {
  213.     static int last_val=0;
  214.     int this_val;
  215.     int delta;
  216.  
  217.     this_val=input_port_5_r(0);
  218.  
  219.     delta=this_val-last_val;
  220.     last_val=this_val;
  221.     if (delta>128) delta-=256;
  222.     else if (delta<-128) delta+=256;
  223.     /* Divide by four to make our steering less sensitive */
  224.     sprint2_steering_buf1+=(delta/4);
  225.  
  226.     if (sprint2_steering_buf1>0)
  227.     {
  228.             sprint2_steering_buf1--;
  229.             sprint2_steering_val1=0x7F;
  230.     }
  231.     else if (sprint2_steering_buf1<0)
  232.     {
  233.             sprint2_steering_buf1++;
  234.             sprint2_steering_val1=0x3F;
  235.     }
  236.  
  237.     return sprint2_steering_val1;
  238. }
  239.  
  240. READ_HANDLER( sprint2_steering2_r )
  241. {
  242.     static int last_val=0;
  243.     int this_val;
  244.     int delta;
  245.  
  246.     this_val=input_port_6_r(0);
  247.     delta=this_val-last_val;
  248.     last_val=this_val;
  249.     if (delta>128) delta-=256;
  250.     else if (delta<-128) delta+=256;
  251.     /* Divide by four to make our steering less sensitive */
  252.     sprint2_steering_buf2+=(delta/4);
  253.  
  254.     if (sprint2_steering_buf2>0)
  255.     {
  256.             sprint2_steering_buf2--;
  257.             sprint2_steering_val2=0x7F;
  258.     }
  259.     else if (sprint2_steering_buf2<0)
  260.     {
  261.             sprint2_steering_buf2++;
  262.             sprint2_steering_val2=0x3F;
  263.     }
  264.  
  265.     return sprint2_steering_val2;
  266. }
  267.  
  268. WRITE_HANDLER( sprint2_steering_reset1_w )
  269. {
  270.     sprint2_steering_val1=0xFF;
  271. }
  272.  
  273. WRITE_HANDLER( sprint2_steering_reset2_w )
  274. {
  275.     sprint2_steering_val2=0xFF;
  276. }
  277.  
  278.  
  279.  
  280. /***************************************************************************
  281. Collisions
  282.  
  283. D6=1, skid.  D7=1, crash.
  284.  
  285. Note:  collisions are actually being set in vidhrdw/sprint2.c
  286. ***************************************************************************/
  287. READ_HANDLER( sprint2_collision1_r )
  288. {
  289.     return sprint2_collision1_data;
  290. }
  291.  
  292. READ_HANDLER( sprint2_collision2_r )
  293. {
  294.     return sprint2_collision2_data;
  295. }
  296.  
  297. WRITE_HANDLER( sprint2_collision_reset1_w )
  298. {
  299.     sprint2_collision1_data=0;
  300. }
  301.  
  302. WRITE_HANDLER( sprint2_collision_reset2_w )
  303. {
  304.     sprint2_collision2_data=0;
  305. }
  306.  
  307. /***************************************************************************
  308. Lamps
  309. ***************************************************************************/
  310. WRITE_HANDLER( sprint2_lamp1_w )
  311. {
  312.     osd_led_w(0,(data>0));
  313. }
  314.  
  315. WRITE_HANDLER( sprint2_lamp2_w )
  316. {
  317.     osd_led_w(1,(data>0));
  318. }
  319.  
  320.  
  321.  
  322.